package com.hdu;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import static java.util.concurrent.TimeUnit.SECONDS;

//TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or
// click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);

    public static void main(String[] args) {
        shutdownAndTermination();
    }

    public static void shutdown() {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            if (i == 4) {
                threadPool.shutdown();
            }
            try {
                threadPool.execute(new Task(i + 1));
            } catch (Exception e) {
                log.info("第 {} 次任务被拒绝", i + 1);
            }
        }

        //17:40:47.545 [main] INFO com.hdu.Main - 第 5 次任务被拒绝
        //17:40:47.547 [main] INFO com.hdu.Main - 第 6 次任务被拒绝
        //17:40:47.547 [main] INFO com.hdu.Main - 第 7 次任务被拒绝
        //17:40:47.547 [main] INFO com.hdu.Main - 第 8 次任务被拒绝
        //17:40:47.547 [main] INFO com.hdu.Main - 第 9 次任务被拒绝
        //17:40:47.547 [main] INFO com.hdu.Main - 第 10 次任务被拒绝
        //第 1 次开始执行
        //第 2 次开始执行
        //第 3 次开始执行
        //第 4 次开始执行
    }

    private static void shutdownAndTermination() {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            try {
                threadPool.execute(new Task(i + 1));
            } catch (Exception e) {
                log.info("第 {} 次任务被拒绝", i + 1);
            }
            if (i == 4) {
                threadPool.shutdown();
            }
        }

        try {
            boolean isStop = threadPool.awaitTermination(2, SECONDS);
            if (!isStop) {
                log.info("线程池超时");
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        //17:46:23.414 [main] INFO com.hdu.Main - 第 6 次任务被拒绝
        //17:46:23.416 [main] INFO com.hdu.Main - 第 7 次任务被拒绝
        //17:46:23.416 [main] INFO com.hdu.Main - 第 8 次任务被拒绝
        //17:46:23.416 [main] INFO com.hdu.Main - 第 9 次任务被拒绝
        //17:46:23.416 [main] INFO com.hdu.Main - 第 10 次任务被拒绝
        //第 1 次开始执行
        //第 2 次开始执行
        //17:46:25.429 [main] INFO com.hdu.Main - 线程池超时
        //第 3 次开始执行
        //第 4 次开始执行
        //第 5 次开始执行
    }


    private static void shutdownNow() {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            try {
                threadPool.execute(new Task(i + 1));
            } catch (Exception e) {
                log.info("第 {} 次任务被拒绝", i + 1);
            }
            if (i == 4) {
                List<Runnable> remainTasks = threadPool.shutdownNow();
                for (int j = 0; j < remainTasks.size(); j++) {
                    Runnable task = remainTasks.get(j);
                    if (task instanceof Task) {
                        log.info("第 {} 次任务从任务队列里面移除", ((Task) task).getId());
                    }
                }
            }
        }
        //17:43:00.482 [main] INFO com.hdu.Main - 第 2 次任务从任务队列里面移除
        //17:43:00.482 [pool-1-thread-1] INFO com.hdu.Task - 第 1 次任务被打断了
        //17:43:00.484 [main] INFO com.hdu.Main - 第 3 次任务从任务队列里面移除
        //17:43:00.484 [main] INFO com.hdu.Main - 第 4 次任务从任务队列里面移除
        //17:43:00.484 [main] INFO com.hdu.Main - 第 5 次任务从任务队列里面移除
        //17:43:00.484 [main] INFO com.hdu.Main - 第 6 次任务被拒绝
        //17:43:00.484 [main] INFO com.hdu.Main - 第 7 次任务被拒绝
        //17:43:00.484 [main] INFO com.hdu.Main - 第 8 次任务被拒绝
        //17:43:00.484 [main] INFO com.hdu.Main - 第 9 次任务被拒绝
        //17:43:00.484 [main] INFO com.hdu.Main - 第 10 次任务被拒绝
    }



    public static void shutdownGracefully(ExecutorService threadPool) {
        if (threadPool != null && !threadPool.isShutdown()) {
            log.info("threadPool shutdown");
            threadPool.shutdown();
            try {
                if (!threadPool.awaitTermination(120, SECONDS)) {
                    List<Runnable> remainTasks = threadPool.shutdownNow();
                    for (Runnable task : remainTasks) {
                        if (task instanceof Task) {
                            log.info("第 {} 次任务从任务队列里面移除", ((Task) task).getId());
                            // 在这里可以对这些还未执行的任务做一些处理。
                        }
                    }
                    if (!threadPool.awaitTermination(60, SECONDS)) {
                        log.error("threadPool can not be close");
                    }
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}


